+2007-11-25 Matthias Clasen <mclasen@redhat.com>
+
+ * configure.in: Require gtk-doc 1.8
+
+ * */*.c: Use gtk-doc abbreviations for examples in docs.
+
2007-11-25 Matthias Clasen <mclasen@redhat.com>
* gtk/gtktreeview.c (gtk_tree_view_set_show_expanders): Fix a
AC_ARG_ENABLE(xinerama,
[AC_HELP_STRING([--enable-xinerama],
[support xinerama extension if available [default=yes]])],,
- [enable_xinerama="yes"])
+ [enable_xinerama="no"])
AC_ARG_ENABLE(rebuilds,
[AC_HELP_STRING([--disable-rebuilds],
[disable all source autogeneration rules])],,
# Checks for gtk-doc and docbook-tools
##################################################
-GTK_DOC_CHECK([1.6])
+GTK_DOC_CHECK([1.8])
AC_CHECK_PROG(DB2HTML, db2html, true, false)
AM_CONDITIONAL(HAVE_DOCBOOK, $DB2HTML)
* running in thread A and accessing @self after it has been finalized
* in thread B:
*
- * <informalexample><programlisting>
+ * |[
* static gboolean
* idle_callback (gpointer data)
* {
- * // gdk_threads_enter(); would be needed for g_idle_add()
+ * /* gdk_threads_enter(); would be needed for g_idle_add() */
*
* SomeWidget *self = data;
- * /<!-- -->* do stuff with self *<!-- -->/
+ * /* do stuff with self */
*
* self->idle_id = 0;
*
- * // gdk_threads_leave(); would be needed for g_idle_add()
+ * /* gdk_threads_leave(); would be needed for g_idle_add() */
* return FALSE;
* }
*
* some_widget_do_stuff_later (SomeWidget *self)
* {
* self->idle_id = gdk_threads_add_idle (idle_callback, self)
- * // using g_idle_add() here would require thread protection in the callback
+ * /* using g_idle_add() here would require thread protection in the callback */
* }
*
* static void
* g_source_remove (self->idle_id);
* G_OBJECT_CLASS (parent_class)->finalize (object);
* }
- * </programlisting></informalexample>
+ * ]|
*
* Return value: the ID (greater than 0) of the event source.
*
* This variant of g_timeout_add_full() can be thought of a MT-safe version
* for GTK+ widgets for the following use case:
*
- * <informalexample><programlisting>
+ * |[
* static gboolean timeout_callback (gpointer data)
* {
* SomeWidget *self = data;
*
- * /<!-- -->* do stuff with self *<!-- -->/
+ * /* do stuff with self */
*
* self->timeout_id = 0;
*
*
* static void some_widget_finalize (GObject *object)
* {
- * SomeWidget *self = SOME_WIDGET(object);
+ * SomeWidget *self = SOME_WIDGET (object);
*
* if (self->timeout_id)
* g_source_remove (self->timeout_id);
*
* G_OBJECT_CLASS (parent_class)->finalize (object);
* }
- * </programlisting></informalexample>
+ * ]|
*
* Return value: the ID (greater than 0) of the event source.
*
* gdk_display_get_default:
*
* Gets the default #GdkDisplay. This is a convenience
- * function for:
- * <programlisting>
- * gdk_display_manager_get_default_display (gdk_display_manager_get ())
- * </programlisting>
+ * function for
+ * <literal>gdk_display_manager_get_default_display (gdk_display_manager_get ())</literal>.
*
* Returns: a #GdkDisplay, or %NULL if there is no default
* display.
* core pointer. Coordinate extraction, processing and requesting more
* motion events from a %GDK_MOTION_NOTIFY event usually works like this:
*
- * <informalexample><programlisting>
- * { // motion_event handler
+ * |[
+ * {
+ * /* motion_event handler */
* x = motion_event->x;
* y = motion_event->y;
- * ; // handle (x,y) motion
- * gdk_event_request_motions (motion_event); // handles is_hint events
+ * /* handle (x,y) motion */
+ * gdk_event_request_motions (motion_event); /* handles is_hint events */
* }
- * </programlisting></informalexample>
+ * ]|
*
* Since: 2.12
**/
* of the language which is currently used in the user interface.
* Using gettext(), a simple way to achieve that is to mark the
* string for translation:
- * <informalexample><programlisting>
+ * |[
* gtk_about_dialog_set_translator_credits (about, _("translator-credits"));
- * </programlisting></informalexample>
+ * ]|
* It is a good idea to use the customary msgid "translator-credits" for this
* purpose, since translators will already know the purpose of that msgid, and
* since #GtkAboutDialog will detect if "translator-credits" is untranslated
* continue to use the same kind of widget for editing in future
* releases, therefore you should check the type of @editable
* before doing any specific setup, as in the following example:
- *
- * <informalexample><programlisting>
+ * |[
* static void
* text_editing_started (GtkCellRenderer *cell,
* GtkCellEditable *editable,
* if (GTK_IS_ENTRY (editable))
* {
* GtkEntry *entry = GTK_ENTRY (editable);
- * <!-- -->
- * /<!-- -->* ... create a GtkEntryCompletion *<!-- -->/
- * <!-- -->
+ *
+ * /* ... create a GtkEntryCompletion */
+ *
* gtk_entry_set_completion (entry, completion);
* }
* }
- * </programlisting></informalexample>
+ * ]|
*
* Since: 2.6
*/
* so the first button in the list will be the leftmost button in the dialog.
*
* Here's a simple example:
- * <informalexample><programlisting>
+ * |[
* GtkWidget *dialog = gtk_dialog_new_with_buttons ("My dialog",
* main_app_window,
* GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
* GTK_STOCK_CANCEL,
* GTK_RESPONSE_REJECT,
* NULL);
- * </programlisting></informalexample>
+ * ]|
*
* Return value: a new #GtkDialog
**/
* destroying the dialog if you wish to do so.
*
* Typical usage of this function might be:
- * <informalexample><programlisting>
+ * |[
* gint result = gtk_dialog_run (GTK_DIALOG (dialog));
* switch (result)
* {
* case GTK_RESPONSE_ACCEPT:
- * do_application_specific_something (<!-- -->);
+ * do_application_specific_something ();
* break;
* default:
- * do_nothing_since_dialog_was_cancelled (<!-- -->);
+ * do_nothing_since_dialog_was_cancelled ();
* break;
* }
* gtk_widget_destroy (dialog);
- * </programlisting></informalexample>
+ * ]|
*
* Note that even though the recursive main loop gives the effect of a
* modal dialog (it prevents the user from interacting with other
*
* Use this function after adding all the buttons to your dialog, as the
* following example shows:
- * <informalexample><programlisting>
+ * |[
* cancel_button = gtk_dialog_add_button (GTK_DIALOG (dialog),
* GTK_STOCK_CANCEL,
* GTK_RESPONSE_CANCEL);
* GTK_RESPONSE_CANCEL,
* GTK_RESPONSE_HELP,
* -1);
- * </programlisting></informalexample>
+ * ]|
*
* Since: 2.6
*/
* Note that the file must exist, or nothing will be done except
* for the directory change.
*
- * If you are implementing a <guimenuitem>File/Save As...</guimenuitem> dialog, you
- * should use this function if you already have a file name to which the user may save; for example,
- * when the user opens an existing file and then does <guimenuitem>File/Save As...</guimenuitem>
- * on it. If you don't have a file name already — for example, if the user just created
- * a new file and is saving it for the first time, do not call this function. Instead, use
- * something similar to this:
- *
- * <programlisting>
+ * If you are implementing a <guimenuitem>File/Save As...</guimenuitem> dialog,
+ * you should use this function if you already have a file name to which the
+ * user may save; for example, when the user opens an existing file and then
+ * does <guimenuitem>File/Save As...</guimenuitem> on it. If you don't have
+ * a file name already — for example, if the user just created a new
+ * file and is saving it for the first time, do not call this function.
+ * Instead, use something similar to this:
+ * |[
* if (document_is_new)
* {
- * /<!-- -->* the user just created a new document *<!-- -->/
+ * /* the user just created a new document */
* gtk_file_chooser_set_current_folder (chooser, default_folder_for_saving);
* gtk_file_chooser_set_current_name (chooser, "Untitled document");
* }
* else
* {
- * /<!-- -->* the user edited an existing document *<!-- -->/
+ * /* the user edited an existing document */
* gtk_file_chooser_set_filename (chooser, existing_filename);
* }
- * </programlisting>
+ * ]|
*
* Return value: %TRUE if both the folder could be changed and the file was
* selected successfully, %FALSE otherwise.
* to a sequence of gtk_file_chooser_unselect_all() followed by
* gtk_file_chooser_select_uri().
*
- * Note that the URI must exist, or nothing will be done except
- * for the directory change.
- * If you are implementing a <guimenuitem>File/Save As...</guimenuitem> dialog, you
- * should use this function if you already have a file name to which the user may save; for example,
- * when the user opens an existing file and then does <guimenuitem>File/Save As...</guimenuitem>
- * on it. If you don't have a file name already — for example, if the user just created
- * a new file and is saving it for the first time, do not call this function. Instead, use
- * something similar to this:
- *
- * <programlisting>
+ * Note that the URI must exist, or nothing will be done except for the
+ * directory change.
+ * If you are implementing a <guimenuitem>File/Save As...</guimenuitem> dialog,
+ * you should use this function if you already have a file name to which the
+ * user may save; for example, when the user opens an existing file and then
+ * does <guimenuitem>File/Save As...</guimenuitem> on it. If you don't have
+ * a file name already — for example, if the user just created a new
+ * file and is saving it for the first time, do not call this function.
+ * Instead, use something similar to this:
+ * |[
* if (document_is_new)
* {
- * /<!-- -->* the user just created a new document *<!-- -->/
+ * /* the user just created a new document */
* gtk_file_chooser_set_current_folder_uri (chooser, default_folder_for_saving);
* gtk_file_chooser_set_current_name (chooser, "Untitled document");
* }
* else
* {
- * /<!-- -->* the user edited an existing document *<!-- -->/
+ * /* the user edited an existing document */
* gtk_file_chooser_set_uri (chooser, existing_uri);
* }
- * </programlisting>
+ * ]|
*
* Return value: %TRUE if both the folder could be changed and the URI was
* selected successfully, %FALSE otherwise.
* gtk_file_filter_add_mime_type(), gtk_file_filter_add_pattern(),
* or gtk_file_filter_add_custom(). To create a filter
* that accepts any file, use:
- *
- * <informalexample><programlisting>
- * GtkFileFilter *filter = gtk_file_filter_new (<!-- -->);
+ * |[
+ * GtkFileFilter *filter = gtk_file_filter_new ();
* gtk_file_filter_add_pattern (filter, "*");
- * </programlisting></informalexample>
+ * ]|
*
* Return value: a new #GtkFileFilter
*
* To do this, you can use gtk_tree_row_reference_new().
*
* To free the return value, use:
- * <informalexample><programlisting>
+ * |[
* g_list_foreach (list, gtk_tree_path_free, NULL);
* g_list_free (list);
- * </programlisting></informalexample>
+ * ]|
*
* Return value: A #GList containing a #GtkTreePath for each selected row.
*
* label's text and attribute list based on the parse results. If the @str is
* external data, you may need to escape it with g_markup_escape_text() or
* g_markup_printf_escaped()<!-- -->:
- * <informalexample><programlisting>
+ * |[
* char *markup;
- * <!-- -->
+ *
* markup = g_markup_printf_escaped ("<span style=\"italic\">%s</span>", str);
* gtk_label_set_markup (GTK_LABEL (label), markup);
* g_free (markup);
- * </programlisting></informalexample>
+ * ]|
**/
void
gtk_label_set_markup (GtkLabel *label,
* Calling
* <literal>gtk_list_store_insert_with_values(list_store, iter, position...)</literal>
* has the same effect as calling
- * <informalexample><programlisting>
+ * |[
* gtk_list_store_insert (list_store, iter, position);
* gtk_list_store_set (list_store, iter, ...);
- * </programlisting></informalexample>
+ * ]|
* with the difference that the former will only emit a row_inserted signal,
* while the latter will emit row_inserted, row_changed and, if the list store
* is sorted, rows_reordered. Since emitting the rows_reordered signal
* instead, since you can't pass the markup string either
* as the format (it might contain '%' characters) or as a string
* argument.
- *
- * <informalexample><programlisting>
+ * |[
* GtkWidget *dialog;
* dialog = gtk_message_dialog_new (main_application_window,
* GTK_DIALOG_DESTROY_WITH_PARENT,
* NULL);
* gtk_message_dialog_set_markup (GTK_MESSAGE_DIALOG (dialog),
* markup);
- * </programlisting></informalexample>
+ * ]|
*
* Return value: a new #GtkMessageDialog
*
* destination and accept the target "GTK_NOTEBOOK_TAB". The notebook
* will fill the selection with a GtkWidget** pointing to the child
* widget that corresponds to the dropped tab.
- *
- * <informalexample><programlisting>
+ * |[
* static void
* on_drop_zone_drag_data_received (GtkWidget *widget,
* GdkDragContext *context,
* process_widget (*child);
* gtk_container_remove (GTK_CONTAINER (notebook), *child);
* }
- * </programlisting></informalexample>
+ * ]|
*
* If you want a notebook to accept drags from other widgets,
* you will have to set your own DnD code to do it.
* Emitted for every page that is printed. The signal handler
* must render the @page_nr's page onto the cairo context obtained
* from @context using gtk_print_context_get_cairo_context().
- *
- * <informalexample><programlisting>
+ * |[
* static void
* draw_page (GtkPrintOperation *operation,
* GtkPrintContext *context,
* pango_layout_set_width (layout, width * PANGO_SCALE);
* pango_layout_set_alignment (layout, PANGO_ALIGN_CENTER);
*
- * pango_layout_get_size (layout, NULL, &layout_height);
+ * pango_layout_get_size (layout, NULL, &layout_height);
* text_height = (gdouble)layout_height / PANGO_SCALE;
*
* cairo_move_to (cr, width / 2, (HEADER_HEIGHT - text_height) / 2);
*
* g_object_unref (layout);
* }
- * </programlisting></informalexample>
+ * ]|
*
* Use gtk_print_operation_set_use_full_page() and
* gtk_print_operation_set_unit() before starting the print operation
* platform. The #GtkPrintOperation::done signal will be emitted with the
* operation results when the operation is done (i.e. when the dialog is
* canceled, or when the print succeeds or fails).
- *
- * <informalexample><programlisting>
+ * |[
* if (settings != NULL)
* gtk_print_operation_set_print_settings (print, settings);
*
* gtk_print_operation_set_default_page_setup (print, page_setup);
*
* g_signal_connect (print, "begin-print",
- * G_CALLBACK (begin_print), &data);
+ * G_CALLBACK (begin_print), &data);
* g_signal_connect (print, "draw-page",
- * G_CALLBACK (draw_page), &data);
+ * G_CALLBACK (draw_page), &data);
*
- * res = gtk_print_operation_run (print, GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG, parent, &error);
+ * res = gtk_print_operation_run (print,
+ * GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG,
+ * parent,
+ * &error);
*
* if (res == GTK_PRINT_OPERATION_RESULT_ERROR)
* {
* GTK_DIALOG_DESTROY_WITH_PARENT,
* GTK_MESSAGE_ERROR,
* GTK_BUTTONS_CLOSE,
- * "Error printing file:\n%s",
+ * "Error printing file:\n%s",
* error->message);
* g_signal_connect (error_dialog, "response",
* G_CALLBACK (gtk_widget_destroy), NULL);
* g_object_unref (settings);
* settings = g_object_ref (gtk_print_operation_get_print_settings (print));
* }
- * </programlisting></informalexample>
+ * ]|
*
* Note that gtk_print_operation_run() can only be called once on a
* given #GtkPrintOperation.
* to the group.
*
* A common way to set up a group of radio group is the following:
- * <informalexample><programlisting>
+ * |[
* GSList *group = NULL;
* GtkRadioAction *action;
*
- * while (/<!-- -->* more actions to add *<!-- -->/)
+ * while (/* more actions to add */)
* {
* action = gtk_radio_action_new (...);
*
* gtk_radio_action_set_group (action, group);
* group = gtk_radio_action_get_group (action);
* }
- * </programlisting></informalexample>
+ * ]|
*
* Returns: the list representing the radio group for this object
*
* would be items inside a GNOME canvas widget.
*
* The action of gtk_rc_get_style() is similar to:
- * <informalexample><programlisting>
- * gtk_widget_path (widget, NULL, &path, NULL);
- * gtk_widget_class_path (widget, NULL, &class_path, NULL);
- * gtk_rc_get_style_by_paths (gtk_widget_get_settings (widget), path, class_path,
+ * |[
+ * gtk_widget_path (widget, NULL, &path, NULL);
+ * gtk_widget_class_path (widget, NULL, &class_path, NULL);
+ * gtk_rc_get_style_by_paths (gtk_widget_get_settings (widget),
+ * path, class_path,
* G_OBJECT_TYPE (widget));
- * </programlisting></informalexample>
+ * ]|
*
* Return value: A style created by matching with the supplied paths,
* or %NULL if nothing matching was specified and the default style should
* gtk_recent_filter_add_pattern(), gtk_recent_filter_add_mime_type(),
* gtk_recent_filter_add_application(), gtk_recent_filter_add_age().
* To create a filter that accepts any recently used resource, use:
- *
- * <informalexample><programlisting>
- * GtkRecentFilter *filter = gtk_recent_filter_new (<!-- -->);
+ * |[
+ * GtkRecentFilter *filter = gtk_recent_filter_new ();
* gtk_recent_filter_add_pattern (filter, "*");
- * </programlisting></informalexample>
+ * ]|
*
* Return value: a new #GtkRecentFilter
*
* To do this, you can use gtk_tree_row_reference_new().
*
* To free the return value, use:
- * <informalexample><programlisting>
+ * |[
* g_list_foreach (list, gtk_tree_path_free, NULL);
* g_list_free (list);
- * </programlisting></informalexample>
+ * ]|
*
* Return value: A #GList containing a #GtkTreePath for each selected row.
*
* Calling
* <literal>gtk_tree_store_insert_with_values (tree_store, iter, position, ...)</literal>
* has the same effect as calling
- * <informalexample><programlisting>
+ * |[
* gtk_tree_store_insert (tree_store, iter, position);
* gtk_tree_store_set (tree_store, iter, ...);
- * </programlisting></informalexample>
+ * ]|
* with the different that the former will only emit a row_inserted signal,
* while the latter will emit row_inserted, row_changed and if the tree store
* is sorted, rows_reordered. Since emitting the rows_reordered signal
* gtk_tree_view_column_set_attributes() on the newly created #GtkTreeViewColumn.
*
* Here's a simple example:
- * <informalexample><programlisting>
+ * |[
* enum { TEXT_COLUMN, COLOR_COLUMN, N_COLUMNS };
* ...
* {
* GtkTreeViewColumn *column;
- * GtkCellRenderer *renderer = gtk_cell_renderer_text_new (<!-- -->);
+ * GtkCellRenderer *renderer = gtk_cell_renderer_text_new ();
*
* column = gtk_tree_view_column_new_with_attributes ("Title",
* renderer,
* "foreground", COLOR_COLUMN,
* NULL);
* }
- * </programlisting></informalexample>
+ * ]|
*
* Return value: A newly created #GtkTreeViewColumn.
**/
* UI in an idle function. A typical example where this function is
* useful is to enforce that the menubar and toolbar have been added to
* the main window before showing it:
- * <informalexample>
- * <programlisting>
+ * |[
* gtk_container_add (GTK_CONTAINER (window), vbox);
* g_signal_connect (merge, "add_widget",
* G_CALLBACK (add_widget), vbox);
* gtk_ui_manager_add_ui_from_file (merge, "my-toolbars");
* gtk_ui_manager_ensure_update (merge);
* gtk_widget_show (window);
- * </programlisting>
- * </informalexample>
+ * ]|
*
* Since: 2.4
**/
* #GtkWidget::drag-leave and if not, treat the drag-motion signal as an
* "enter" signal. Upon an "enter", the handler will typically highlight
* the drop site with gtk_drag_highlight().
- *
- * <informalexample><programlisting>
+ * |[
* static void
* drag_motion (GtkWidget *widget,
* GdkDragContext *context,
* {
* private_data->suggested_action = 0;
*
- * /<!-- -->* We are getting this data due to a request in drag_motion,
+ * /* We are getting this data due to a request in drag_motion,
* * rather than due to a request in drag_drop, so we are just
- * * supposed to call gdk_drag_status(<!-- -->), not actually paste in
+ * * supposed to call gdk_drag_status (), not actually paste in
* * the data.
- * *<!-- -->/
+ * */
* str = gtk_selection_data_get_text (selection_data);
* if (!data_is_acceptable (str))
* gdk_drag_status (context, 0, time);
* }
* else
* {
- * /<!-- -->* accept the drop *<!-- -->/
+ * /* accept the drop */
* }
* }
- * </programlisting></informalexample>
+ * ]|
*/
widget_signals[DRAG_MOTION] =
g_signal_new (I_("drag_motion"),
* The handler may inspect and modify @drag_context->action before calling
* gtk_drag_finish(), e.g. to implement %GDK_ACTION_ASK as shown in the
* following example:
- * <informalexample><programlisting>
+ * |[
* void
* drag_data_received (GtkWidget *widget,
* GdkDragContext *drag_context,
*
* gtk_drag_finish (drag_context, FALSE, FALSE, time);
* }
- * </programlisting></informalexample>
+ * ]|
*/
widget_signals[DRAG_DATA_RECEIVED] =
g_signal_new (I_("drag_data_received"),
* Note that the background is still drawn when the widget is mapped.
* If this is not suitable (e.g. because you want to make a transparent
* window using an RGBA visual), you can work around this by doing:
- * <informalexample><programlisting>
+ * |[
* gtk_widget_realize (window);
* gdk_window_set_back_pixmap (window->window, NULL, FALSE);
* gtk_widget_show (window);
- * </programlisting></informalexample>
+ * ]|
**/
void
gtk_widget_set_app_paintable (GtkWidget *widget,
* To reliably find the toplevel #GtkWindow, use
* gtk_widget_get_toplevel() and check if the %TOPLEVEL flags
* is set on the result.
- * <informalexample><programlisting>
+ * |[
* GtkWidget *toplevel = gtk_widget_get_toplevel (widget);
* if (GTK_WIDGET_TOPLEVEL (toplevel))
* {
- * [ Perform action on toplevel. ]
+ * /* Perform action on toplevel. */
* }
- * </programlisting></informalexample>
+ * ]|
*
* Return value: the topmost ancestor of @widget, or @widget itself
* if there's no ancestor.
* builders might want to treat them in a different way.
*
* Here is a simple example:
- * <informalexample><programlisting>
- * gtk_widget_push_composite_child (<!-- -->);
+ * |[
+ * gtk_widget_push_composite_child ();
* scrolled_window->hscrollbar = gtk_hscrollbar_new (hadjustment);
* gtk_widget_set_composite_name (scrolled_window->hscrollbar, "hscrollbar");
- * gtk_widget_pop_composite_child (<!-- -->);
+ * gtk_widget_pop_composite_child ();
* gtk_widget_set_parent (scrolled_window->hscrollbar,
* GTK_WIDGET (scrolled_window));
* g_object_ref (scrolled_window->hscrollbar);
- * </programlisting></informalexample>
+ * ]|
**/
void
gtk_widget_push_composite_child (void)
* to be called when the window has its "final" size, i.e. after calling
* gtk_widget_show_all() on the contents and gtk_window_set_geometry_hints()
* on the window.
- *
- * <informalexample><programlisting>
- * #include <gtk/gtk.h>
+ * |[
+ * #include <gtk/gtk.h>
*
* static void
* fill_with_content (GtkWidget *vbox)
* {
- * /<!-- -->* fill with content... *<!-- -->/
+ * /* fill with content... */
* }
*
* int
* 100, 50, 0, 0, 100, 50, 10, 10, 0.0, 0.0, GDK_GRAVITY_NORTH_WEST
* };
*
- * gtk_init (&argc, &argv);
+ * gtk_init (&argc, &argv);
*
* window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
* vbox = gtk_vbox_new (FALSE, 0);
*
* gtk_window_set_geometry_hints (GTK_WINDOW (window),
* window,
- * &size_hints,
+ * &size_hints,
* GDK_HINT_MIN_SIZE |
* GDK_HINT_BASE_SIZE |
* GDK_HINT_RESIZE_INC);
* if (argc > 1)
* {
* if (!gtk_window_parse_geometry (GTK_WINDOW (window), argv[1]))
- * fprintf (stderr, "Failed to parse '%s'\n", argv[1]);
+ * fprintf (stderr, "Failed to parse '%s'\n", argv[1]);
* }
*
* gtk_widget_show_all (window);
*
* return 0;
* }
- * </programlisting></informalexample>
+ * ]|
*
* Return value: %TRUE if string was parsed successfully
**/
projects / gtk4.git / commitdiff